package com.struts.action;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.util.CompoundRoot;
import com.opensymphony.xwork2.util.ValueStack;
import com.struts.pojo.Student;

public class ObjectStackAction extends ActionSupport{
	
	/**
	 * 把对象放入对象栈的第一种方式
	 */
	public String addDataToObjectStack_1() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//把字符串对象"aaaaa"放入到对象栈CompoundRoot的第一个位置——栈顶
		valueStack.push("aaaaa") ;
		return SUCCESS ;
	}
	
	/**
	 * 把对象放入对象栈的第二种方式
	 */
	@SuppressWarnings("unchecked")
	public String addDataToObjectStack_2() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//获取对象栈的实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//把字符串对象"aaaaa"放入到对象栈的任意位置——参数0为栈顶
		root.add(0, "aaaaa") ;
		return SUCCESS ;
	}
	
	/**
	 * 把对象放入对象栈的第三种方式
	 */
	@SuppressWarnings("unchecked")
	public String addDataToObjectStack_3() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//先把{String=aaaaa}这个map对象放入到map栈中，Struts2会自动将其放入到对象栈中
		valueStack.set("String", "aaaaa") ;
		CompoundRoot root = valueStack.getRoot() ;
		//循环遍历输出对象栈中的元素
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		return SUCCESS ;
	}
	
	/**
	 * 从对象栈中提取数据的第一种方式
	 */
	public String getDataFromObjectStack_1() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//弹出对象栈的栈顶元素，并从对象栈中移除
		valueStack.pop() ;
		return SUCCESS ;
	}
	
	/**
	 * 从对象栈中提取数据的第二种方式
	 */
	public String getDataFromObjectStack_2() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//获取对象栈的栈顶元素
		valueStack.peek() ;
		return SUCCESS ;
	}
	
	/**
	 * 从对象栈中提取数据的第三种方式
	 */
	public String getDataFromObjectStack_3() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//获取对象栈的实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//获取栈顶元素
		root.get(0) ;
		return SUCCESS ;
	}
	
	/**
	 * 把对象栈的栈顶元素从对象栈中移除的第一种方式
	 */
	public String removeDataFromObjectStack_1() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//直接弹出对象栈的栈顶元素
		valueStack.pop() ;
		return SUCCESS ;
	} 
	
	/**
	 * 把对象栈的栈顶元素从对象栈中移除的第二种方式
	 */
	public String removeDataFromObjectStack_2() {
		//获取值栈对象
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//获取对象栈实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//将栈顶元素从对象栈中移除
		root.remove(0) ;
		return SUCCESS ;
	} 
	
	/**
	 * 测试01将字符串"aaaaa"放入对象栈的栈顶并弹出
	 */
	public String testObjectStack_1() {
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//将"aaaaa"字符串放入到对象栈的栈顶：实际上是放到了valueStack实例化对象ognlValueStack中对象栈root即list集合的list[0]中
		valueStack.push("aaaaa") ;
		//将对象栈中的栈顶元素弹出：获取栈顶元素并从对象栈中移除
		System.out.println(valueStack.pop());
		return SUCCESS ;
	}
	
	/**
	 * 测试02将字符串"aaaaa"放入对象栈中,循环遍历输入对象栈中的元素
	 */
	public String testObjectStack_2() {
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//获取对象栈的实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//将字符串"aaaaa"添加到对象栈中指定位置
		root.add(1, "aaaaa") ;
		//获取对象栈中的值
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		return SUCCESS ;
	}
	
	/**
	 * 测试03：
	 * 		1、将map:key="String",value="aaaaa"放入到对象栈中
	 * 		2、循环遍历输入对象栈中的元素
	 * 		3、从对象栈中取出map对象，根据map中的key输入对应的value值
	 */
	public String testObjectStack_3() {
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//获取对象栈的实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//创建map对象：key="String",value="aaaaa"
		Map<String, String> map = new HashMap<String, String>() ;
		map.put("String", "aaaaa") ;
		//将map对象放入到对象栈的栈顶
		root.add(0, map) ;
		//循环遍历输入对象栈中的元素
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		//从对象栈中获取栈顶map元素
		Map<String, String> object = (Map<String, String>) root.get(0) ;
		System.out.println(object.get("String"));
		return SUCCESS ;
	}
	
	/**
	 * 测试04：
	 * 		1、创建一个pojo对象，将其放入到对象栈中
	 * 		2、循环遍历对象栈中的元素
	 * 		3、从对象栈中获取这个pojo对象，输入该对象的属性值
	 * 		4、将该对象从对象栈中移除，循环遍历输出对象栈中的元素，验证是否移除成功	
	 */
	public String testObjectStack_4() {
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//创建一个pojo对象，并对其初始化
		Student stu = new Student("zhangsan",21) ;
		//获取对象栈的实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//将pojo添加到对象栈的指定位置
		root.add(1, stu) ;
		//将pojo添加到对象栈的栈低
//		root.add(stu) ;
		//循环遍历输出对象栈中的元素
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		//从对象栈中取出该pojo元素
		Student student = (Student)root.get(1) ;
		System.out.println(student);
		//将pojo从对象栈中移除，循环遍历输出对象栈中的元素
		root.remove(1) ;
//		root.remove(stu) ;
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		return SUCCESS ;
	}
	
	/**
	 * 测试05：
	 * 		1、创建pojo集合，将其放入到对象栈中
	 * 		2、循环遍历对象栈中的元素
	 * 		3、从对象栈中获取这个pojo集合，遍历输出
	 * 		4、将该集合从对象栈中移除，循环遍历输出对象栈中的元素，验证是否移除成功
	 */
	public String testObjectStack_5() {
		ValueStack valueStack = ActionContext.getContext().getValueStack() ;
		//创建List<Student>集合
		List<Student> students = new ArrayList<Student>() ;
		students.add(new Student("zhangsan01", 21)) ;
		students.add(new Student("zhangsan02", 22)) ;
		students.add(new Student("zhangsan03", 23)) ;
		//获取对象栈的实例化对象
		CompoundRoot root = valueStack.getRoot() ;
		//将students添加到对象栈中
		root.add(1, students) ;
		//循环遍历输出对象栈中的元素
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		//从对象栈中获取studets对象
		List<Student> list = (List<Student>) root.get(1) ;
		for (Student student : list) {
			System.out.println(student);
		}
		//强students从对象栈中移除
		root.remove(students) ;
		//循环遍历输出对象栈中的元素
		for (int i = 0; i < root.size(); i++) {
			System.out.println(root.get(i));
		}
		return SUCCESS ;
	}
	
}
